home *** CD-ROM | disk | FTP | other *** search
/ Komputer for Alle 1999 #5 / 1999 CD 5 (black).iso / Delphi3 / install / data.z / SHELLAPI.PAS < prev    next >
Encoding:
Pascal/Delphi Source File  |  1997-08-04  |  17.8 KB  |  464 lines
  1.  
  2. {*******************************************************}
  3. {                                                       }
  4. {       Delphi Runtime Library                          }
  5. {       Windows 32bit API Interface Unit                }
  6. {                                                       }
  7. {       Copyright (c) 1992,97 Borland International     }
  8. {                                                       }
  9. {*******************************************************}
  10.  
  11. unit ShellAPI;
  12.  
  13. {$WEAKPACKAGEUNIT}
  14.  
  15. interface
  16.  
  17. uses Windows;
  18.  
  19. type
  20.   HDROP = Longint;
  21.   PPWideChar = ^PWideChar;
  22.  
  23. function DragQueryFileA(Drop: HDROP; FileIndex: UINT; FileName: PAnsiChar; cb: UINT): UINT; stdcall;
  24. function DragQueryFileW(Drop: HDROP; FileIndex: UINT; FileName: PWideChar; cb: UINT): UINT; stdcall;
  25. function DragQueryFile(Drop: HDROP; FileIndex: UINT; FileName: PChar; cb: UINT): UINT; stdcall;
  26. function DragQueryPoint(Drop: HDROP; var Point: TPoint): BOOL; stdcall;
  27. procedure DragFinish(Drop: HDROP); stdcall;
  28. procedure DragAcceptFiles(Wnd: HWND; Accept: BOOL); stdcall;
  29. function ShellExecuteA(hWnd: HWND; Operation, FileName, Parameters,
  30.   Directory: PAnsiChar; ShowCmd: Integer): HINST; stdcall;
  31. function ShellExecuteW(hWnd: HWND; Operation, FileName, Parameters,
  32.   Directory: PWideChar; ShowCmd: Integer): HINST; stdcall;
  33. function ShellExecute(hWnd: HWND; Operation, FileName, Parameters,
  34.   Directory: PChar; ShowCmd: Integer): HINST; stdcall;
  35. function FindExecutableA(FileName, Directory: PAnsiChar; Result: PAnsiChar): HINST; stdcall;
  36. function FindExecutableW(FileName, Directory: PWideChar; Result: PWideChar): HINST; stdcall;
  37. function FindExecutable(FileName, Directory: PChar; Result: PChar): HINST; stdcall;
  38. function CommandLineToArgvW(lpCmdLine: LPCWSTR; var pNumArgs: Integer): PPWideChar; stdcall;
  39. function ShellAboutA(Wnd: HWND; szApp, szOtherStuff: PAnsiChar; Icon: HICON): Integer; stdcall;
  40. function ShellAboutW(Wnd: HWND; szApp, szOtherStuff: PWideChar; Icon: HICON): Integer; stdcall;
  41. function ShellAbout(Wnd: HWND; szApp, szOtherStuff: PChar; Icon: HICON): Integer; stdcall;
  42. function DuplicateIcon(hInst: HINST; Icon: HICON): HICON; stdcall;
  43. function ExtractAssociatedIconA(hInst: HINST; lpIconPath: PAnsiChar;
  44.   var lpiIcon: Word): HICON; stdcall;
  45. function ExtractAssociatedIconW(hInst: HINST; lpIconPath: PWideChar;
  46.   var lpiIcon: Word): HICON; stdcall;
  47. function ExtractAssociatedIcon(hInst: HINST; lpIconPath: PChar;
  48.   var lpiIcon: Word): HICON; stdcall;
  49. function ExtractIconA(hInst: HINST; lpszExeFileName: PAnsiChar;
  50.   nIconIndex: UINT): HICON; stdcall;
  51. function ExtractIconW(hInst: HINST; lpszExeFileName: PWideChar;
  52.   nIconIndex: UINT): HICON; stdcall;
  53. function ExtractIcon(hInst: HINST; lpszExeFileName: PChar;
  54.   nIconIndex: UINT): HICON; stdcall;
  55.  
  56. type
  57.   PDragInfoA = ^TDragInfoA;
  58.   PDragInfoW = ^TDragInfoW;
  59.   PDragInfo = PDragInfoA;
  60.   TDragInfoA = record
  61.     uSize: UINT;                 { init with SizeOf(DRAGINFO) }
  62.     pt: TPoint;
  63.     fNC: BOOL;
  64.     lpFileList: PAnsiChar;
  65.     grfKeyState: DWORD;
  66.   end;
  67.   TDragInfoW = record
  68.     uSize: UINT;                 { init with SizeOf(DRAGINFO) }
  69.     pt: TPoint;
  70.     fNC: BOOL;
  71.     lpFileList: PWideChar;
  72.     grfKeyState: DWORD;
  73.   end;
  74.   TDragInfo = TDragInfoA;
  75.  
  76. const
  77. { AppBar stuff }
  78.  
  79.   ABM_NEW           = $00000000;
  80.   ABM_REMOVE        = $00000001;
  81.   ABM_QUERYPOS      = $00000002;
  82.   ABM_SETPOS        = $00000003;
  83.   ABM_GETSTATE      = $00000004;
  84.   ABM_GETTASKBARPOS = $00000005;
  85.   ABM_ACTIVATE      = $00000006;  { lParam = True/False means activate/deactivate }
  86.   ABM_GETAUTOHIDEBAR = $00000007;
  87.   ABM_SETAUTOHIDEBAR = $00000008;  { this can fail at any time.  MUST check the result
  88.                                      lParam = TRUE/FALSE  Set/Unset
  89.                                      uEdge = what edge }
  90.   ABM_WINDOWPOSCHANGED = $0000009;
  91.  
  92. { these are put in the wparam of callback messages }
  93.  
  94.   ABN_STATECHANGE    = $0000000;
  95.   ABN_POSCHANGED     = $0000001;
  96.   ABN_FULLSCREENAPP  = $0000002;
  97.   ABN_WINDOWARRANGE  = $0000003; { lParam = True means hide }
  98.  
  99. { flags for get state }
  100.  
  101.   ABS_AUTOHIDE    = $0000001;
  102.   ABS_ALWAYSONTOP = $0000002;
  103.  
  104.   ABE_LEFT        = 0;
  105.   ABE_TOP         = 1;
  106.   ABE_RIGHT       = 2;
  107.   ABE_BOTTOM      = 3;
  108.  
  109. type
  110.   PAppBarData = ^TAppBarData;
  111.   TAppBarData = record
  112.     cbSize: DWORD;
  113.     hWnd: HWND;
  114.     uCallbackMessage: UINT;
  115.     uEdge: UINT;
  116.     rc: TRect;
  117.     lParam: LPARAM; { message specific }
  118.   end;
  119.  
  120. function SHAppBarMessage(dwMessage: DWORD; var pData: TAppBarData): UINT; stdcall;
  121.  
  122.  
  123. function DoEnvironmentSubstA(szString: PAnsiChar; cbString: UINT): DWORD; stdcall;
  124. function DoEnvironmentSubstW(szString: PWideChar; cbString: UINT): DWORD; stdcall;
  125. function DoEnvironmentSubst(szString: PChar; cbString: UINT): DWORD; stdcall;
  126. function ExtractIconExA(lpszFile: PAnsiChar; nIconIndex: Integer; 
  127.   var phiconLarge, phiconSmall: HICON; nIcons: UINT): UINT; stdcall;
  128. function ExtractIconExW(lpszFile: PWideChar; nIconIndex: Integer; 
  129.   var phiconLarge, phiconSmall: HICON; nIcons: UINT): UINT; stdcall;
  130. function ExtractIconEx(lpszFile: PChar; nIconIndex: Integer; 
  131.   var phiconLarge, phiconSmall: HICON; nIcons: UINT): UINT; stdcall;
  132.  
  133.  
  134. { Shell File Operations }
  135.  
  136. const
  137.   FO_MOVE           = $0001;
  138.   FO_COPY           = $0002;
  139.   FO_DELETE         = $0003;
  140.   FO_RENAME         = $0004;
  141.  
  142.   FOF_MULTIDESTFILES         = $0001;
  143.   FOF_CONFIRMMOUSE           = $0002;
  144.   FOF_SILENT                 = $0004;  { don't create progress/report }
  145.   FOF_RENAMEONCOLLISION      = $0008;
  146.   FOF_NOCONFIRMATION         = $0010;  { Don't prompt the user. }
  147.   FOF_WANTMAPPINGHANDLE      = $0020;  { Fill in SHFILEOPSTRUCT.hNameMappings
  148.                                          Must be freed using SHFreeNameMappings }
  149.   FOF_ALLOWUNDO              = $0040;
  150.   FOF_FILESONLY              = $0080;  { on *.*, do only files }
  151.   FOF_SIMPLEPROGRESS         = $0100;  { means don't show names of files }
  152.   FOF_NOCONFIRMMKDIR         = $0200;  { don't confirm making any needed dirs }
  153.   FOF_NOERRORUI              = $0400;  { don't put up error UI }
  154.  
  155. type
  156.   FILEOP_FLAGS = Word;
  157.  
  158. const
  159.   PO_DELETE       = $0013;  { printer is being deleted }
  160.   PO_RENAME       = $0014;  { printer is being renamed }
  161.   PO_PORTCHANGE   = $0020;  { port this printer connected to is being changed
  162.                               if this id is set, the strings received by
  163.                               the copyhook are a doubly-null terminated
  164.                               list of strings.  The first is the printer
  165.                               name and the second is the printer port. }
  166.   PO_REN_PORT     = $0034;  { PO_RENAME and PO_PORTCHANGE at same time. }
  167.  
  168. { no POF_ flags currently defined }
  169.  
  170. type
  171.   PRINTEROP_FLAGS = Word;
  172.  
  173. { implicit parameters are:
  174.       if pFrom or pTo are unqualified names the current directories are
  175.       taken from the global current drive/directory settings managed
  176.       by Get/SetCurrentDrive/Directory
  177.  
  178.       the global confirmation settings }
  179.  
  180.   PSHFileOpStructA = ^TSHFileOpStructA;
  181.   PSHFileOpStructW = ^TSHFileOpStructW;
  182.   PSHFileOpStruct = PSHFileOpStructA;
  183.   TSHFileOpStructA = packed record
  184.     Wnd: HWND;
  185.     wFunc: UINT;
  186.     pFrom: PAnsiChar;
  187.     pTo: PAnsiChar;
  188.     fFlags: FILEOP_FLAGS;
  189.     fAnyOperationsAborted: BOOL;
  190.     hNameMappings: Pointer;
  191.     lpszProgressTitle: PAnsiChar; { only used if FOF_SIMPLEPROGRESS }
  192.   end;
  193.   TSHFileOpStructW = packed record
  194.     Wnd: HWND;
  195.     wFunc: UINT;
  196.     pFrom: PWideChar;
  197.     pTo: PWideChar;
  198.     fFlags: FILEOP_FLAGS;
  199.     fAnyOperationsAborted: BOOL;
  200.     hNameMappings: Pointer;
  201.     lpszProgressTitle: PWideChar; { only used if FOF_SIMPLEPROGRESS }
  202.   end;
  203.   TSHFileOpStruct = TSHFileOpStructA;
  204.  
  205. function SHFileOperationA(const lpFileOp: TSHFileOpStructA): Integer; stdcall;
  206. function SHFileOperationW(const lpFileOp: TSHFileOpStructW): Integer; stdcall;
  207. function SHFileOperation(const lpFileOp: TSHFileOpStruct): Integer; stdcall;
  208. procedure SHFreeNameMappings(hNameMappings: THandle); stdcall;
  209.  
  210. type
  211.   PSHNameMappingA = ^TSHNameMappingA;
  212.   PSHNameMappingW = ^TSHNameMappingW;
  213.   PSHNameMapping = PSHNameMappingA;
  214.   TSHNameMappingA = record
  215.     pszOldPath: PAnsiChar;
  216.     pszNewPath: PAnsiChar;
  217.     cchOldPath: Integer;
  218.     cchNewPath: Integer;
  219.   end;
  220.   TSHNameMappingW = record
  221.     pszOldPath: PWideChar;
  222.     pszNewPath: PWideChar;
  223.     cchOldPath: Integer;
  224.     cchNewPath: Integer;
  225.   end;
  226.   TSHNameMapping = TSHNameMappingA;
  227.  
  228.  
  229. { ShellExecute() and ShellExecuteEx() error codes }
  230. const
  231. { regular WinExec() codes }
  232.   SE_ERR_FNF              = 2;       { file not found }
  233.   SE_ERR_PNF              = 3;       { path not found }
  234.   SE_ERR_ACCESSDENIED     = 5;       { access denied }
  235.   SE_ERR_OOM              = 8;       { out of memory }
  236.   SE_ERR_DLLNOTFOUND      = 32;
  237.  
  238. { error values for ShellExecute() beyond the regular WinExec() codes }
  239.   SE_ERR_SHARE                    = 26;
  240.   SE_ERR_ASSOCINCOMPLETE          = 27;
  241.   SE_ERR_DDETIMEOUT               = 28;
  242.   SE_ERR_DDEFAIL                  = 29;
  243.   SE_ERR_DDEBUSY                  = 30;
  244.   SE_ERR_NOASSOC                  = 31;
  245.  
  246. { Note CLASSKEY overrides CLASSNAME }
  247.   SEE_MASK_CLASSNAME      = $00000001;
  248.   SEE_MASK_CLASSKEY       = $00000003;
  249. { Note INVOKEIDLIST overrides IDLIST }
  250.   SEE_MASK_IDLIST         = $00000004;
  251.   SEE_MASK_INVOKEIDLIST   = $0000000c;
  252.   SEE_MASK_ICON           = $00000010;
  253.   SEE_MASK_HOTKEY         = $00000020;
  254.   SEE_MASK_NOCLOSEPROCESS = $00000040;
  255.   SEE_MASK_CONNECTNETDRV  = $00000080;
  256.   SEE_MASK_FLAG_DDEWAIT   = $00000100;
  257.   SEE_MASK_DOENVSUBST     = $00000200;
  258.   SEE_MASK_FLAG_NO_UI     = $00000400;
  259.   SEE_MASK_UNICODE        = $00010000; // !!! changed from previous SDK (was $00004000)
  260.   SEE_MASK_NO_CONSOLE     = $00008000; 
  261.   SEE_MASK_ASYNCOK        = $00100000; 
  262.       
  263. type
  264.   PShellExecuteInfoA = ^TShellExecuteInfoA;
  265.   PShellExecuteInfoW = ^TShellExecuteInfoW;
  266.   PShellExecuteInfo = PShellExecuteInfoA;
  267.   TShellExecuteInfoA = record
  268.     cbSize: DWORD;
  269.     fMask: ULONG;
  270.     Wnd: HWND;
  271.     lpVerb: PAnsiChar;
  272.     lpFile: PAnsiChar;
  273.     lpParameters: PAnsiChar;
  274.     lpDirectory: PAnsiChar;
  275.     nShow: Integer;
  276.     hInstApp: HINST;
  277.     { Optional fields }
  278.     lpIDList: Pointer;
  279.     lpClass: PAnsiChar;
  280.     hkeyClass: HKEY;
  281.     dwHotKey: DWORD;
  282.     hIcon: THandle;
  283.     hProcess: THandle;
  284.   end;
  285.   TShellExecuteInfoW = record
  286.     cbSize: DWORD;
  287.     fMask: ULONG;
  288.     Wnd: HWND;
  289.     lpVerb: PWideChar;
  290.     lpFile: PWideChar;
  291.     lpParameters: PWideChar;
  292.     lpDirectory: PWideChar;
  293.     nShow: Integer;
  294.     hInstApp: HINST;
  295.     { Optional fields }
  296.     lpIDList: Pointer;
  297.     lpClass: PWideChar;
  298.     hkeyClass: HKEY;
  299.     dwHotKey: DWORD;
  300.     hIcon: THandle;
  301.     hProcess: THandle;
  302.   end;
  303.   TShellExecuteInfo = TShellExecuteInfoA;
  304.  
  305. function ShellExecuteExA(lpExecInfo: PShellExecuteInfoA):BOOL; stdcall;
  306. function ShellExecuteExW(lpExecInfo: PShellExecuteInfoW):BOOL; stdcall;
  307. function ShellExecuteEx(lpExecInfo: PShellExecuteInfo):BOOL; stdcall;
  308.  
  309. { Tray notification definitions }
  310.  
  311. type
  312.   PNotifyIconDataA = ^TNotifyIconDataA;
  313.   PNotifyIconDataW = ^TNotifyIconDataW;
  314.   PNotifyIconData = PNotifyIconDataA;
  315.   TNotifyIconDataA = record
  316.     cbSize: DWORD;
  317.     Wnd: HWND;
  318.     uID: UINT;
  319.     uFlags: UINT;
  320.     uCallbackMessage: UINT;
  321.     hIcon: HICON;
  322.     szTip: array [0..63] of AnsiChar;
  323.   end;
  324.   TNotifyIconDataW = record
  325.     cbSize: DWORD;
  326.     Wnd: HWND;
  327.     uID: UINT;
  328.     uFlags: UINT;
  329.     uCallbackMessage: UINT;
  330.     hIcon: HICON;
  331.     szTip: array [0..63] of WideChar;
  332.   end;
  333.   TNotifyIconData = TNotifyIconDataA;
  334.  
  335. const
  336.   NIM_ADD         = $00000000;
  337.   NIM_MODIFY      = $00000001;
  338.   NIM_DELETE      = $00000002;
  339.  
  340.   NIF_MESSAGE     = $00000001;
  341.   NIF_ICON        = $00000002;
  342.   NIF_TIP         = $00000004;
  343.  
  344. function Shell_NotifyIconA(dwMessage: DWORD; lpData: PNotifyIconDataA): BOOL; stdcall;
  345. function Shell_NotifyIconW(dwMessage: DWORD; lpData: PNotifyIconDataW): BOOL; stdcall;
  346. function Shell_NotifyIcon(dwMessage: DWORD; lpData: PNotifyIconData): BOOL; stdcall;
  347.  
  348. { Begin SHGetFileInfo }
  349.  
  350. (*
  351.  * The SHGetFileInfo API provides an easy way to get attributes
  352.  * for a file given a pathname.
  353.  *
  354.  *   PARAMETERS
  355.  *
  356.  *     pszPath              file name to get info about
  357.  *     dwFileAttributes     file attribs, only used with SHGFI_USEFILEATTRIBUTES
  358.  *     psfi                 place to return file info
  359.  *     cbFileInfo           size of structure
  360.  *     uFlags               flags
  361.  *
  362.  *   RETURN
  363.  *     TRUE if things worked
  364.  *)
  365.  
  366. type
  367.   PSHFileInfoA = ^TSHFileInfoA;
  368.   PSHFileInfoW = ^TSHFileInfoW;
  369.   PSHFileInfo = PSHFileInfoA;
  370.   TSHFileInfoA = record
  371.     hIcon: HICON;                      { out: icon }
  372.     iIcon: Integer;                    { out: icon index }
  373.     dwAttributes: DWORD;               { out: SFGAO_ flags }
  374.     szDisplayName: array [0..MAX_PATH-1] of  AnsiChar; { out: display name (or path) }
  375.     szTypeName: array [0..79] of AnsiChar;             { out: type name }
  376.   end;
  377.   TSHFileInfoW = record
  378.     hIcon: HICON;                      { out: icon }
  379.     iIcon: Integer;                    { out: icon index }
  380.     dwAttributes: DWORD;               { out: SFGAO_ flags }
  381.     szDisplayName: array [0..MAX_PATH-1] of  WideChar; { out: display name (or path) }
  382.     szTypeName: array [0..79] of WideChar;             { out: type name }
  383.   end;
  384.   TSHFileInfo = TSHFileInfoA;
  385.  
  386. const
  387.   SHGFI_ICON              = $000000100;     { get icon }
  388.   SHGFI_DISPLAYNAME       = $000000200;     { get display name }
  389.   SHGFI_TYPENAME          = $000000400;     { get type name }
  390.   SHGFI_ATTRIBUTES        = $000000800;     { get attributes }
  391.   SHGFI_ICONLOCATION      = $000001000;     { get icon location }
  392.   SHGFI_EXETYPE           = $000002000;     { return exe type }
  393.   SHGFI_SYSICONINDEX      = $000004000;     { get system icon index }
  394.   SHGFI_LINKOVERLAY       = $000008000;     { put a link overlay on icon }
  395.   SHGFI_SELECTED          = $000010000;     { show icon in selected state }
  396.   SHGFI_LARGEICON         = $000000000;     { get large icon }
  397.   SHGFI_SMALLICON         = $000000001;     { get small icon }
  398.   SHGFI_OPENICON          = $000000002;     { get open icon }
  399.   SHGFI_SHELLICONSIZE     = $000000004;     { get shell size icon }
  400.   SHGFI_PIDL              = $000000008;     { pszPath is a pidl }
  401.   SHGFI_USEFILEATTRIBUTES = $000000010;     { use passed dwFileAttribute }
  402.  
  403. function SHGetFileInfoA(pszPath: PAnsiChar; dwFileAttributes: DWORD; 
  404.   var psfi: TSHFileInfoA; cbFileInfo, uFlags: UINT): DWORD; stdcall;
  405. function SHGetFileInfoW(pszPath: PAnsiChar; dwFileAttributes: DWORD; 
  406.   var psfi: TSHFileInfoW; cbFileInfo, uFlags: UINT): DWORD; stdcall;
  407. function SHGetFileInfo(pszPath: PAnsiChar; dwFileAttributes: DWORD; 
  408.   var psfi: TSHFileInfo; cbFileInfo, uFlags: UINT): DWORD; stdcall;
  409.  
  410. const
  411.   SHGNLI_PIDL             = $000000001;     { pszLinkTo is a pidl }
  412.   SHGNLI_PREFIXNAME       = $000000002;     { Make name "Shortcut to xxx" }
  413.   SHGNLI_NOUNIQUE         = $000000004;     { don't do the unique name generation }
  414.  
  415.   shell32 = 'shell32.dll';
  416.  
  417. implementation
  418.  
  419. function CommandLineToArgvW; external shell32 name 'CommandLineToArgvW';
  420. function DoEnvironmentSubstA; external shell32 name 'DoEnvironmentSubstA';
  421. function DoEnvironmentSubstW; external shell32 name 'DoEnvironmentSubstW';
  422. function DoEnvironmentSubst; external shell32 name 'DoEnvironmentSubstA';
  423. procedure DragAcceptFiles; external shell32 name 'DragAcceptFiles';
  424. procedure DragFinish; external shell32 name 'DragFinish';
  425. function DragQueryFileA; external shell32 name 'DragQueryFileA';
  426. function DragQueryFileW; external shell32 name 'DragQueryFileW';
  427. function DragQueryFile; external shell32 name 'DragQueryFileA';
  428. function DragQueryPoint; external shell32 name 'DragQueryPoint';
  429. function DuplicateIcon; external shell32 name 'DuplicateIcon';
  430. function ExtractAssociatedIconA; external shell32 name 'ExtractAssociatedIconA';
  431. function ExtractAssociatedIconW; external shell32 name 'ExtractAssociatedIconW';
  432. function ExtractAssociatedIcon; external shell32 name 'ExtractAssociatedIconA';
  433. function ExtractIconA; external shell32 name 'ExtractIconA';
  434. function ExtractIconW; external shell32 name 'ExtractIconW';
  435. function ExtractIcon; external shell32 name 'ExtractIconA';
  436. function ExtractIconExA; external shell32 name 'ExtractIconExA';
  437. function ExtractIconExW; external shell32 name 'ExtractIconExW';
  438. function ExtractIconEx; external shell32 name 'ExtractIconExA';
  439. function FindExecutableA; external shell32 name 'FindExecutableA';
  440. function FindExecutableW; external shell32 name 'FindExecutableW';
  441. function FindExecutable; external shell32 name 'FindExecutableA';
  442. function SHAppBarMessage; external shell32 name 'SHAppBarMessage';
  443. function SHFileOperationA; external shell32 name 'SHFileOperationA';
  444. function SHFileOperationW; external shell32 name 'SHFileOperationW';
  445. function SHFileOperation; external shell32 name 'SHFileOperationA';
  446. procedure SHFreeNameMappings; external shell32 name 'SHFreeNameMappings';
  447. function SHGetFileInfoA; external shell32 name 'SHGetFileInfoA';
  448. function SHGetFileInfoW; external shell32 name 'SHGetFileInfoW';
  449. function SHGetFileInfo; external shell32 name 'SHGetFileInfoA';
  450. function ShellAboutA; external shell32 name 'ShellAboutA';
  451. function ShellAboutW; external shell32 name 'ShellAboutW';
  452. function ShellAbout; external shell32 name 'ShellAboutA';
  453. function ShellExecuteA; external shell32 name 'ShellExecuteA';
  454. function ShellExecuteW; external shell32 name 'ShellExecuteW';
  455. function ShellExecute; external shell32 name 'ShellExecuteA';
  456. function ShellExecuteExA; external shell32 name 'ShellExecuteExA';
  457. function ShellExecuteExW; external shell32 name 'ShellExecuteExW';
  458. function ShellExecuteEx; external shell32 name 'ShellExecuteExA';
  459. function Shell_NotifyIconA; external shell32 name 'Shell_NotifyIconA';
  460. function Shell_NotifyIconW; external shell32 name 'Shell_NotifyIconW';
  461. function Shell_NotifyIcon; external shell32 name 'Shell_NotifyIconA';
  462.  
  463. end.
  464.